const fs = require('fs');
const path = require('path');

/**
 * 高级基础物品数据转换工具
 */
class BasicItemsConverter {
    constructor(inputFile, outputFile) {
        this.inputFile = inputFile;
        this.outputFile = outputFile;
        this.originalData = null;
        this.convertedData = null;
    }

    /**
     * 读取原始数据
     */
    readData() {
        try {
            console.log('开始读取文件...');
            const rawData = fs.readFileSync(this.inputFile, 'utf8');
            this.originalData = JSON.parse(rawData);
            console.log(`成功读取数据，包含 ${Object.keys(this.originalData).length} 个物品`);
            return true;
        } catch (error) {
            console.error('读取文件失败:', error.message);
            return false;
        }
    }

    /**
     * 转换数据格式
     */
    convertData() {
        if (!this.originalData) {
            throw new Error('请先读取数据');
        }

        console.log('开始转换数据格式...');
        this.convertedData = {};

        for (const [itemName, properties] of Object.entries(this.originalData)) {
            if (Array.isArray(properties)) {
                // 将属性数组转换为对象
                const itemObject = {};

                properties.forEach(prop => {
                    if (prop.k && prop.v !== undefined) {
                        // 移除属性名中的冒号
                        const key = prop.k.replace(':', '');
                        itemObject[key] = prop.v;
                    }
                });

                // 添加数值类型的属性，便于排序和筛选
                if (itemObject.价格) {
                    itemObject.价格数值 = this.extractPriceValue(itemObject.价格);
                }
                if (itemObject.等级) {
                    itemObject.等级数值 = parseInt(itemObject.等级) || 0;
                }
                if (itemObject.负重) {
                    itemObject.负重数值 = parseInt(itemObject.负重) || 0;
                }
                if (itemObject.id) {
                    itemObject.id数值 = parseInt(itemObject.id) || 0;
                }

                this.convertedData[itemName] = itemObject;
            }
        }

        console.log('数据转换完成');
        return this.convertedData;
    }

    /**
     * 提取价格数值
     */
    extractPriceValue(priceStr) {
        const match = priceStr.match(/(\d+(?:\.\d+)?)/);
        return match ? parseFloat(match[1]) : 0;
    }

    /**
     * 保存转换后的数据
     */
    saveData() {
        if (!this.convertedData) {
            throw new Error('请先转换数据');
        }

        try {
            fs.writeFileSync(this.outputFile, JSON.stringify(this.convertedData, null, 2), 'utf8');
            console.log(`转换后的数据已保存到: ${this.outputFile}`);
            return true;
        } catch (error) {
            console.error('保存文件失败:', error.message);
            return false;
        }
    }

    /**
     * 生成数据统计
     */
    generateStats() {
        if (!this.convertedData) {
            throw new Error('请先转换数据');
        }

        const stats = {
            总物品数量: Object.keys(this.convertedData).length,
            有价格的物品: 0,
            有等级的物品: 0,
            有负重的物品: 0,
            最高等级: 0,
            最低等级: Infinity,
            最高价格: 0,
            最低价格: Infinity,
            平均价格: 0,
            价格分布: {},
            等级分布: {}
        };

        let totalPrice = 0;
        let priceCount = 0;

        for (const item of Object.values(this.convertedData)) {
            if (item.价格数值 > 0) {
                stats.有价格的物品++;
                stats.最高价格 = Math.max(stats.最高价格, item.价格数值);
                stats.最低价格 = Math.min(stats.最低价格, item.价格数值);
                totalPrice += item.价格数值;
                priceCount++;

                // 价格分布统计
                const priceRange = this.getPriceRange(item.价格数值);
                stats.价格分布[priceRange] = (stats.价格分布[priceRange] || 0) + 1;
            }

            if (item.等级数值 > 0) {
                stats.有等级的物品++;
                stats.最高等级 = Math.max(stats.最高等级, item.等级数值);
                stats.最低等级 = Math.min(stats.最低等级, item.等级数值);

                // 等级分布统计
                const levelRange = this.getLevelRange(item.等级数值);
                stats.等级分布[levelRange] = (stats.等级分布[levelRange] || 0) + 1;
            }

            if (item.负重数值 >= 0) {
                stats.有负重的物品++;
            }
        }

        if (priceCount > 0) {
            stats.平均价格 = Math.round(totalPrice / priceCount);
        }

        return stats;
    }

    /**
     * 获取价格范围分类
     */
    getPriceRange(price) {
        if (price <= 100) return '100两以下';
        if (price <= 500) return '100-500两';
        if (price <= 1000) return '500-1000两';
        if (price <= 5000) return '1000-5000两';
        return '5000两以上';
    }

    /**
     * 获取等级范围分类
     */
    getLevelRange(level) {
        if (level <= 5) return '1-5级';
        if (level <= 10) return '6-10级';
        if (level <= 20) return '11-20级';
        if (level <= 50) return '21-50级';
        return '50级以上';
    }

    /**
     * 筛选物品
     */
    filterItems(filters = {}) {
        if (!this.convertedData) {
            throw new Error('请先转换数据');
        }

        let filtered = Object.entries(this.convertedData);

        if (filters.minLevel !== undefined) {
            filtered = filtered.filter(([_, item]) => item.等级数值 >= filters.minLevel);
        }

        if (filters.maxLevel !== undefined) {
            filtered = filtered.filter(([_, item]) => item.等级数值 <= filters.maxLevel);
        }

        if (filters.minPrice !== undefined) {
            filtered = filtered.filter(([_, item]) => item.价格数值 >= filters.minPrice);
        }

        if (filters.maxPrice !== undefined) {
            filtered = filtered.filter(([_, item]) => item.价格数值 <= filters.maxPrice);
        }

        if (filters.nameContains) {
            filtered = filtered.filter(([name, item]) =>
                name.includes(filters.nameContains) ||
                item.介绍?.includes(filters.nameContains)
            );
        }

        if (filters.type) {
            filtered = filtered.filter(([name, item]) =>
                name.includes(filters.type) ||
                item.介绍?.includes(filters.type)
            );
        }

        return Object.fromEntries(filtered);
    }

    /**
     * 排序物品
     */
    sortItems(data, sortBy = '名称', order = 'asc') {
        const items = Object.entries(data);

        items.sort(([nameA, itemA], [nameB, itemB]) => {
            let valueA, valueB;

            switch (sortBy) {
                case '价格':
                    valueA = itemA.价格数值 || 0;
                    valueB = itemB.价格数值 || 0;
                    break;
                case '等级':
                    valueA = itemA.等级数值 || 0;
                    valueB = itemB.等级数值 || 0;
                    break;
                case '负重':
                    valueA = itemA.负重数值 || 0;
                    valueB = itemB.负重数值 || 0;
                    break;
                case '名称':
                default:
                    valueA = nameA;
                    valueB = nameB;
                    break;
            }

            if (order === 'desc') {
                return valueB > valueA ? 1 : -1;
            } else {
                return valueA > valueB ? 1 : -1;
            }
        });

        return Object.fromEntries(items);
    }

    /**
     * 导出为CSV格式
     */
    exportToCSV(data, outputFile) {
        const csvHeader = '名称,价格,等级,负重,介绍,ID\n';
        let csvContent = csvHeader;

        for (const [name, item] of Object.entries(data)) {
            const row = [
                name,
                item.价格 || '',
                item.等级 || '',
                item.负重 || '',
                `"${(item.介绍 || '').replace(/"/g, '""')}"`,
                item.id || ''
            ].join(',');

            csvContent += row + '\n';
        }

        try {
            fs.writeFileSync(outputFile, csvContent, 'utf8');
            console.log(`CSV文件已导出到: ${outputFile}`);
            return true;
        } catch (error) {
            console.error('导出CSV失败:', error.message);
            return false;
        }
    }

    /**
     * 显示转换示例
     */
    showExamples(count = 3) {
        if (!this.convertedData) {
            throw new Error('请先转换数据');
        }

        const sampleItems = Object.entries(this.convertedData).slice(0, count);
        console.log('\n转换示例:');
        sampleItems.forEach(([itemName, item]) => {
            console.log(`\n${itemName}:`);
            console.log(JSON.stringify(item, null, 2));
        });
    }

    /**
     * 验证转换后的数据
     */
    validateData() {
        if (!this.convertedData) {
            throw new Error('请先转换数据');
        }

        console.log('\n数据验证:');
        console.log(`总物品数量: ${Object.keys(this.convertedData).length}`);

        const firstItemName = Object.keys(this.convertedData)[0];
        const firstItem = this.convertedData[firstItemName];

        console.log(`\n第一个物品 "${firstItemName}" 的结构:`);
        console.log(JSON.stringify(firstItem, null, 2));

        const requiredFields = ['名称', '价格', '等级', '负重', '介绍', 'id'];
        const missingFields = requiredFields.filter(field => !(field in firstItem));

        if (missingFields.length > 0) {
            console.log(`\n警告: 缺少字段: ${missingFields.join(', ')}`);
        } else {
            console.log('\n✓ 所有必需字段都存在');
        }
    }

    /**
     * 执行完整的转换流程
     */
    async execute() {
        try {
            console.log('=== 高级基础物品数据转换工具 ===');
            console.log(`输入文件: ${this.inputFile}`);
            console.log(`输出文件: ${this.outputFile}`);
            console.log('');

            // 检查输入文件
            if (!fs.existsSync(this.inputFile)) {
                throw new Error(`输入文件不存在: ${this.inputFile}`);
            }

            // 读取数据
            if (!this.readData()) {
                return false;
            }

            // 转换数据
            this.convertData();

            // 保存数据
            if (!this.saveData()) {
                return false;
            }

            // 显示示例
            this.showExamples(3);

            // 验证数据
            this.validateData();

            // 生成统计信息
            const stats = this.generateStats();
            console.log('\n=== 数据统计 ===');
            console.log(JSON.stringify(stats, null, 2));

            // 示例筛选和排序
            console.log('\n=== 筛选和排序示例 ===');

            // 筛选等级1-5的物品
            const lowLevelItems = this.filterItems({ minLevel: 1, maxLevel: 5 });
            console.log(`等级1-5的物品数量: ${Object.keys(lowLevelItems).length}`);

            // 筛选价格低于100两的物品
            const cheapItems = this.filterItems({ maxPrice: 100 });
            console.log(`价格低于100两的物品数量: ${Object.keys(cheapItems).length}`);

            // 筛选包含"药"字的物品
            const medicineItems = this.filterItems({ nameContains: '药' });
            console.log(`包含"药"字的物品数量: ${Object.keys(medicineItems).length}`);

            // 按价格排序
            const sortedByPrice = this.sortItems(this.convertedData, '价格', 'desc');
            const topExpensive = Object.entries(sortedByPrice).slice(0, 5);
            console.log('\n最贵的5个物品:');
            topExpensive.forEach(([name, item]) => {
                console.log(`${name}: ${item.价格}`);
            });

            console.log('\n=== 转换完成 ===');
            return true;

        } catch (error) {
            console.error('程序执行失败:', error.message);
            return false;
        }
    }
}

/**
 * 主函数
 */
function main() {
    const inputFile = path.join(__dirname, 'output', 'websocket_data_基础物品.json');
    const outputFile = path.join(__dirname, 'output', 'basic_items_advanced.json');
    const csvFile = path.join(__dirname, 'output', 'basic_items.csv');

    const converter = new BasicItemsConverter(inputFile, outputFile);

    converter.execute().then(success => {
        if (success) {
            // 导出CSV
            const convertedData = converter.convertedData;
            converter.exportToCSV(convertedData, csvFile);
        }
    });
}

// 如果直接运行此脚本
if (require.main === module) {
    main();
}

module.exports = BasicItemsConverter;
